SAMPLE={'股东-居然之家上市公告书中的前十大股东是哪些？':'''
user:A股-居然之家的注册地址在哪？
assistant:```python
doc_searcher.search_by_question("A股-居然之家的注册地址在哪？")
```
user:文档略
assistant:<thought>
需求分析：用户需要查询A股公司“居然之家”的注册地址。需要从数据库中查找相关信息。

文档分析：需要查询 LC_StockArchives 表中的注册地址字段。居然之家的公司代码是 385。

查询字段：
- CompanyCode: 公司代码，用于过滤公司
- RegAddr: 注册地址字段

回答分析：通过查询 LC_StockArchives 表，根据公司代码 385，获取注册地址。

具体步骤如下：
1. 使用公司代码 385 作为过滤条件，查询 LC_StockArchives 表中的注册地址字段。
2. 输出查询结果。
</thought>
```python
company_code = 385
query = select(LC_StockArchives.RegAddr).where(LC_StockArchives.CompanyCode == company_code)
print("查询居然之家注册地址开始")
result = exec_orm_sql(query.compile(engine, compile_kwargs={"literal_binds": True}))
print("查询居然之家注册地址结束")
reg_address = result.iloc[0]['RegAddr'] if not result.empty else None
print(f"【答案:{reg_address}】")
```
请执行上述代码以查询居然之家的注册地址。
user:A股-居然之家上市公告书中的前十大股东是哪些？
assistant:```python
doc_searcher.search_by_question("A股-居然之家上市公告书中的前十大股东是哪些？")
```
user:文档略
assistant:<thought>
需求分析：
需要查询居然之家上市公告书中的前十大股东信息。
需要找到最新的 InfoPublDate，并基于这个日期筛选信息。

文档分析：
需要查询的字段包括：GDID, SHList, SHType, InfoPublDate, CompanyCode, InfoTypeCode。
需要使用 InfoTypeCode 为 1 的记录，表示前十大股东的信息。
需要找到最新的 InfoPublDate，以获取最新的前十大股东信息。
用户需求展示的字段应该为 SHList。

查询步骤：
1. 构建子查询，找到最新的 InfoPublDate。
2. 构建主查询，基于子查询的结果筛选出最新 InfoPublDate 的前十大股东信息。
</thought>
```python
# 公司代码
company_code = 385
# 构建子查询，找到最新的 InfoPublDate
subquery = select(
    func.max(LC_MainSHListNew.InfoPublDate)
).where(
    LC_MainSHListNew.CompanyCode == company_code,
    LC_MainSHListNew.InfoTypeCode == 1  # InfoTypeCode为1表示前十大股东
).scalar_subquery()

# 构建主查询，筛选出最新 InfoPublDate 的前十大股东信息
query = select(
    LC_MainSHListNew.GDID,
    LC_MainSHListNew.SHList,
    LC_MainSHListNew.SHType,
    LC_MainSHListNew.InfoPublDate,
    LC_MainSHListNew.CompanyCode,
    LC_MainSHListNew.InfoTypeCode
).where(
    LC_MainSHListNew.CompanyCode == company_code,
    LC_MainSHListNew.InfoTypeCode == 1,  # InfoTypeCode为1表示前十大股东
    LC_MainSHListNew.InfoPublDate == subquery  # 筛选最新的 InfoPublDate
)

print("查询居然之家上市公告书中的前十大股东信息开始")
result = exec_orm_sql(query.compile(engine, compile_kwargs={"literal_binds": True}))
print("查询居然之家上市公告书中的前十大股东信息结束")
```
user:       GDID                           SHList SHType  \
0    225108.0                 北京居然之家投资控股集团有限公司   其他股东   
1    386991.0                    霍尔果斯慧鑫达建材有限公司   其他股东   
2    281597.0                 阿里巴巴(中国)网络技术有限公司   其他股东   
3         NaN                              汪林朋   其他股东   
4    296855.0           杭州瀚云新领股权投资基金合伙企业(有限合伙)   其他股东   
5    250631.0                     泰康人寿保险有限责任公司   其他股东   
6  10048475.0               天津睿通投资管理合伙企业(有限合伙)   其他股东   
7    343373.0             青岛好荣兴多商业资产投资中心(有限合伙)   其他股东   
8    184958.0                   武汉商联(集团)股份有限公司   国有股东   
9  10048478.0  上海云锋新创投资管理有限公司-上海云锋五新投资中心(有限合伙)   其他股东

# 备注，如果多次失败，且用户回复你`基于聊天记录回答`,你会通过自然语言推理答案。
user:A股-这些股东里有几家是基金管理公司？
assistant:```python
doc_searcher.search_by_question("A股-居然之家上市公告书中的前十大股东是哪些？")
```
user:文档略
assistant:回答1
user:错误答案
assistant:回答2
user:错误答案
user:基于聊天记录回答
assistant:<thought>好的，根据之前的聊天记录，十大股东为。。。这些公司没有基金管理公司</thought>
【答案：0】
''',
 "涨幅-2020年5月涨幅前10的港股股票有哪些？":"""
user:港股-2020年5月涨幅前10的港股股票有哪些？
assistant:```python
doc_searcher.search_by_question("港股-2020年5月涨幅前10的港股股票有哪些？")
```
user:文档略
assistant:<thought>
需求分析：
需要查询2020年5月涨幅前10的港股股票。月涨幅指的是月末最后一个交易日的涨幅，需要先找到最后一个交易日，然后确定月涨幅。

文档分析：
需要查询的字段包括：TradingDay, InnerCode, SecuCode, ChangePCTTM。
需要在2020年5月的交易日内找到最后一个交易日，并基于该日期筛选涨幅前10的港股股票。排序字段选择 ChangePCTTM 即本月以来涨幅。

查询步骤：
1. 构建子查询，找到2020年5月最后一个交易日。
2. 基于子查询的结果，构建主查询，筛选出2020年5月最后一个交易日涨幅前10的港股股票。
</thought>
```python
# 查询2020年5月涨幅前十的港股股票
max_trading_day_may = (
    select(func.max(CS_HKStockPerformance.TradingDay).label("LatestTradingDay"))
    .where(func.year(CS_HKStockPerformance.TradingDay) == 2020)
    .where(func.month(CS_HKStockPerformance.TradingDay) == 5)
).cte('MaxTradingDayMay')

query_may = (
    select(
        CS_HKStockPerformance.InnerCode,
        HK_SecuMain.SecuCode,
        CS_HKStockPerformance.TradingDay,
        CS_HKStockPerformance.ChangePCTTM
    )
    .select_from(CS_HKStockPerformance)
    .join(max_trading_day_may, CS_HKStockPerformance.TradingDay == max_trading_day_may.c.LatestTradingDay)
    .join(HK_SecuMain, CS_HKStockPerformance.InnerCode == HK_SecuMain.InnerCode)
    .order_by(desc(CS_HKStockPerformance.ChangePCTTM))
    .limit(10)
)

print("查询5月涨幅前十")
result_may = exec_orm_sql(query_may.compile(engine, compile_kwargs={"literal_binds": True}))
print("涨幅前10的股票代码为：",result_may['SecuCode'])
```
user:港股-2020年6月涨幅前10的港股股票有哪些？
assistant:```python
doc_searcher.search_by_question("港股-2020年6月涨幅前10的港股股票有哪些？")
```
user:文档略
assistant:<thought>
需求分析：
需要查询2020年6月这些股票的涨幅。需要找到2020年6月最后一个交易日，然后确定这些股票在该日期的涨幅。

文档分析：
需要查询的字段包括：TradingDay, InnerCode, SecuCode, ChangePCTTM。
需要在2020年6月的交易日内找到最后一个交易日，并基于该日期筛选这些股票的涨幅。

查询步骤：
1. 构建子查询，找到2020年6月最后一个交易日。
2. 基于子查询的结果，构建主查询，筛选出2020年6月最后一个交易日这些股票的涨幅。
</thought>
```python
# 查询2020年6月这些股票的涨幅
max_trading_day_june = (
    select(func.max(CS_HKStockPerformance.TradingDay).label("LatestTradingDay"))
    .where(func.year(CS_HKStockPerformance.TradingDay) == 2020)
    .where(func.month(CS_HKStockPerformance.TradingDay) == 6)
).cte('MaxTradingDayJune')

query_june = (
    select(
        CS_HKStockPerformance.InnerCode,
        HK_SecuMain.SecuCode,
        CS_HKStockPerformance.TradingDay,
        CS_HKStockPerformance.ChangePCTTM
    )
    .select_from(CS_HKStockPerformance)
    .join(max_trading_day_june, CS_HKStockPerformance.TradingDay == max_trading_day_june.c.LatestTradingDay)
    .join(HK_SecuMain, CS_HKStockPerformance.InnerCode == HK_SecuMain.InnerCode)
    .where(CS_HKStockPerformance.InnerCode.in_(result_may['InnerCode'].tolist()))
)

print("查询6月涨幅")
result_june = exec_orm_sql(query_june.compile(engine, compile_kwargs={"literal_binds": True}))
```
user:2020年5月涨幅前十的股票中， 6月涨幅最小的是？
assistant:```python
doc_searcher.search_by_question("港股-2020年6月涨幅前10的港股股票有哪些？")
```
user:文档略
assistant:<thought>
需求分析：
需要找到2020年5月涨幅前十的股票中，2020年6月涨幅最小的股票。

文档分析：
需要从2020年6月的涨幅数据中筛选出涨幅最小的股票。

查询步骤：
1. 从result_june中找到涨幅最小的记录。
2. 输出这条记录的信息。
</thought>
```python
# 找出2020年6月涨幅最小的股票
min_change_june = result_june.loc[result_june['ChangePCTTM'].idxmin()]
# 输出结果
print("2020年5月涨幅前十的股票中，2020年6月涨幅最小的是：")
print(min_change_june)
```
 """,
   "行业概念-2021年纳入的这些概念的股票有多少只？分别属于哪些三级行业？":"""
user:A股-化工纳入过多少个子概念？
assistant:```python
doc_searcher.search_by_question("A股-化工纳入过多少个子概念")
```
user:文档略
assistant:<thought>
需求分析：用户的问题是关于某个股票概念的数量统计。具体来说，用户想知道该概念下的股票一共纳入过多少，以及当前未终止的有多少。根据问题中的关键词，化工类概念是二级概念，统计的时三级概念的数量，用户的问题是纳入过，有一个是否终止字段可能无需考虑，为了稳妥起见，我需要查询所有的文档，然后回答用户一共纳入过多少，未终止的未多少。

文档分析：根据文档，子概念需要统计的时三级概念的数量，用户的问题是纳入过，有一个是否终止字段可能无需考虑，为了稳妥起见，我需要查询所有的文档，然后回答用户一共纳入过多少，未终止的未多少。为了准确回答用户的问题，需要查询以下字段：
- SubclassName：用于过滤二级概念
- ConceptState：用于过滤所有状态的概念，该字段为动态调整的字段，会随时间变化
- ConceptName：用于计数
- ConceptCode：根据注意事项，需要召回Code

回答分析：因为 `ConceptState` 是不确定字段，根据注意事项，我需要在pandas里进行过滤，并回答两个答案：一共纳入过多少个概念，未终止的有多少个。
</thought>
查询代码为:
```python
# Step 1: 查询化工类概念的数量及状态
query_concepts = (
    select(
        LC_ConceptList.ConceptName,
        LC_ConceptList.ConceptState,
        LC_ConceptList.ConceptCode
    ).where(
        and_(
            LC_ConceptList.SubclassName == '化工',
            LC_ConceptList.ConceptState.in_([0, 1])
        )
    )
)
print("开始执行SQL")
df_concepts = exec_orm_sql(query_concepts.compile(engine, compile_kwargs={"literal_binds": True}))
df_active_concepts = df_concepts[df_concepts['ConceptState'] == 1]
print("SQL执行完毕")
print(f"一共纳入过{len(df_concepts)}个，未终止的有{len(df_active_concepts)}个")
```
user:A股-2021年化工纳入过多少个概念？
assistant:```python
doc_searcher.search_by_question("A股-2021年化工纳入过多少个概念")
```
user:文档略
assistant:<thought>
需求分析：用户进一步询问2021年纳入的化工类概念的股票数量及其所属的三级行业。

数据分析：根据用户的问题，我们需要获取以下信息：
1. 2021年纳入的化工类概念
2. 这些概念的股票数量
3. 这些股票所属的三级行业

查询字段：
- SubclassName: 用于过滤二级概念（化工类）
- ConceptState: 用于过滤概念的状态（是否终止）
- ConceptName: 用于统计概念的数量
- ConceptCode: 用于确保数据的完整性
- BeginDate: 用于过滤时间（2021年）
- StockCode: 用于统计股票数量
- IndustryLevel3: 用于获取股票所属的三级行业

回答分析：由于 `ConceptState` 字段是动态变化的，因此需要在数据查询后使用 pandas 进行筛选和统计，确保结果的准确性。此次查询可以在前一步查询结果的基础上进行进一步过滤。具体步骤如下：
1. 查询2021年纳入的化工类概念
2. 统计这些概念的股票数量
3. 获取这些股票所属的三级行业
</thought>
```python
# 在第一步的查询基础上，添加2021年的时间条件
query_2021_concepts = query_concepts.where(
    func.year(LC_ConceptList.BeginDate) ==  2021
)
print("开始执行SQL")
df_2021_concepts = exec_orm_sql(query_2021_concepts.compile(engine, compile_kwargs={"literal_binds": True}))
df_2021_active_concepts = df_2021_concepts[df_2021_concepts['ConceptState'] == 1]
print("SQL执行完毕")
print(f"一共纳入过{len(df_2021_concepts)}个，未终止的有{len(df_2021_active_concepts)}个, 分别是{df_2021_concepts['ConceptName'].values}")
```
user:2021年纳入的这些概念的股票有多少只？分别属于哪些三级行业？
doc_searcher.search_by_question("A股-2021年纳入的这些概念的股票有多少只？分别属于哪些三级行业？")
```
user:文档略
assistant:<thought>
需求分析：用户需要知道2021年纳入的化工类概念的股票数量及其所属的三级行业，需要统计股票数量，并找到这些股票所属的三级行业。

文档分析：首先需要查询2021年纳入的化工类概念的股票数量，然后根据这些股票找到其所属的三级行业。需要注意的是，LC_ExgIndustry 表使用 CompanyCode 关联，而 LC_ConceptList 表使用 InnerCode 关联，因此需要使用 SecuMain 表进行转换。

查询字段：
- ConceptCode: 概念代码，用于表连接
- CompanyCode: 公司代码，用于统计公司数量
- ThirdIndustryName: 三级行业名称
- ThirdIndustryCode: 三级行业代码
- IfPerformed: 是否执行（必须为“是”才有效）
- InDate: 用于过滤时间（2021年）

回答分析：因为 `ConceptState` 是动态调整的字段，需要在 pandas 里进行过滤，并回答两个问题：2021年纳入的这些概念的股票数量，以及这些股票所属的三级行业。此次查询可以使用前一步的结果作为子查询。
</thought>
```python
# 查询2021年纳入的这些概念的股票数量及其三级行业

concept_codes = df_2021_concepts['ConceptCode'].to_list()

query_stocks = (
    select(LC_COConcept.InnerCode)
    .where(
        and_(
            LC_COConcept.ConceptCode.in_(concept_codes),
            func.year(LC_COConcept.InDate) == 2021
        )
    )
    .distinct()
)

print("开始执行SQL")
result_stocks = exec_orm_sql(query_stocks.compile(engine, compile_kwargs={"literal_binds": True}))

inner_codes = result_stocks['InnerCode'].to_list()

# 查询这些股票对应的公司代码
query_company_codes = (
    select(SecuMain.CompanyCode)
    .where(
        SecuMain.InnerCode.in_(inner_codes)
    )
    .distinct()
)
print("开始执行SQL")
result_company_codes = exec_orm_sql(query_company_codes.compile(engine, compile_kwargs={"literal_binds": True}))
company_codes =result_company_codes['CompanyCode'].to_list()

# 查询这些公司代码对应的三级行业
query_industries = (
    select(LC_ExgIndustry.ThirdIndustryName, LC_ExgIndustry.ThirdIndustryCode)
    .where(
        LC_ExgIndustry.CompanyCode.in_(company_codes)
    )
    .where(
        LC_ExgIndustry.IfPerformed==1
    )
)
print("开始执行SQL")
df_industries = exec_orm_sql(query_industries.compile(engine, compile_kwargs={"literal_binds": True}))
third_industries = set(df_industries['ThirdIndustryName'])

print(f"2021年纳入的这些概念的股票：{len(inner_codes)}, 三级行业为：{third_industries}")
```

"""}


SAMPLE_MSG = [
    {'role':"user",
     "content":""},
    {'role':"assistant",
     "content":""},
    {'role': "user",
     "content": ""},
    {'role': "assistant",
     "content": ""},
    {'role': "user",
     "content": ""},
    {'role': "assistant",
     "content": ""},
    {'role': "user",
     "content": ""},
    {'role': "assistant",
     "content": ""},
    {'role': "user",
     "content": ""},
    {'role': "assistant",
     "content": ""},

]